﻿using System;
using UnityEngine;
using UnityEngine.EventSystems;
using Utility;

// Token: 0x02000138 RID: 312
public class IllusionCamera : MonoBehaviour
{
	// Token: 0x170000C7 RID: 199
	// (get) Token: 0x06000703 RID: 1795 RVA: 0x0002977C File Offset: 0x0002797C
	public float Distance
	{
		get
		{
			return this.distance;
		}
	}

	// Token: 0x170000C8 RID: 200
	// (get) Token: 0x06000704 RID: 1796 RVA: 0x00029784 File Offset: 0x00027984
	public Vector3 Focus
	{
		get
		{
			return this.nowFocus;
		}
	}

	// Token: 0x170000C9 RID: 201
	// (get) Token: 0x06000705 RID: 1797 RVA: 0x0002978C File Offset: 0x0002798C
	public Vector3 Rotation
	{
		get
		{
			return this.rotate;
		}
	}

	// Token: 0x170000CA RID: 202
	// (get) Token: 0x06000706 RID: 1798 RVA: 0x00029794 File Offset: 0x00027994
	public float FOV
	{
		get
		{
			return this.camera.fieldOfView;
		}
	}

	// Token: 0x170000CB RID: 203
	// (get) Token: 0x06000707 RID: 1799 RVA: 0x000297A4 File Offset: 0x000279A4
	public CameraTarget Target
	{
		get
		{
			return this.target;
		}
	}

	// Token: 0x170000CC RID: 204
	// (get) Token: 0x06000708 RID: 1800 RVA: 0x000297AC File Offset: 0x000279AC
	// (set) Token: 0x06000709 RID: 1801 RVA: 0x000297B4 File Offset: 0x000279B4
	public bool OnUI { get; private set; }

	// Token: 0x170000CD RID: 205
	// (get) Token: 0x0600070A RID: 1802 RVA: 0x000297C0 File Offset: 0x000279C0
	// (set) Token: 0x0600070B RID: 1803 RVA: 0x000297C8 File Offset: 0x000279C8
	public bool Lock { get; set; }

	// Token: 0x0600070C RID: 1804 RVA: 0x000297D4 File Offset: 0x000279D4
	private void Awake()
	{
		this.camera = base.GetComponent<Camera>();
		this.viewCollider = base.gameObject.AddComponent<CapsuleCollider>();
		this.viewCollider.radius = 0.05f;
		this.viewCollider.isTrigger = true;
		this.viewCollider.direction = 2;
		this.viewCollider.gameObject.layer = base.gameObject.layer;
		this.buttonState[0] = IllusionCamera.ButtonState.NO;
		this.buttonState[2] = IllusionCamera.ButtonState.NO;
		this.buttonState[1] = IllusionCamera.ButtonState.NO;
	}

	// Token: 0x0600070D RID: 1805 RVA: 0x0002985C File Offset: 0x00027A5C
	private void Start()
	{
		this.defParse = ConfigData.defParse;
		this.camera.fieldOfView = this.defParse;
		if (this.target)
		{
			this.target.Move(this.setFocus, this.showTgt);
		}
	}

	// Token: 0x0600070E RID: 1806 RVA: 0x000298AC File Offset: 0x00027AAC
	private void LateUpdate()
	{
		if (this.camera == null)
		{
			return;
		}
		this.showTgt = ConfigData.showFocusUI;
		this.mouseSensitivity = ConfigData.mouseSensitive;
		this.mouseRevY = ConfigData.mouseRevV;
		this.mouseRevX = ConfigData.mouseRevH;
		this.centerDragMove = ConfigData.centerDragMove;
		this.dragLock = ConfigData.dragLock;
		this.keySensitivity = ConfigData.keySensitive * 0.5f;
		this.keyRevY = ConfigData.keyRevV;
		this.keyRevX = ConfigData.keyRevH;
		this.defParse = ConfigData.defParse;
		float num = Input.GetAxis("Mouse X") * this.mouseSensitivity;
		float num2 = Input.GetAxis("Mouse Y") * this.mouseSensitivity;
		if (Input.GetKey(KeyCode.LeftShift))
		{
			num *= 3f;
			num2 *= 3f;
		}
		if (Input.GetKey(KeyCode.LeftControl))
		{
			num *= 0.25f;
			num2 *= 0.25f;
		}
		bool flag = false;
		this.OnUI = (EventSystem.current && EventSystem.current.IsPointerOverGameObject());
		this.ButtonStateCheck();
		if (!this.OnUI && !this.Lock && (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1) || Input.GetMouseButtonDown(2)))
		{
			this.dragging = true;
		}
		else if (!Input.GetMouseButton(0) && !Input.GetMouseButton(1) && !Input.GetMouseButton(2))
		{
			this.dragging = false;
		}
		if (this.dragging)
		{
			if (this.dragLock)
			{
				GameCursor.Lock();
			}
			if (Input.GetMouseButton(0) && Input.GetMouseButton(1))
			{
				flag = true;
				if (this.centerDragMove == IllusionCamera.CenterDragMove.XY)
				{
					this.Translate(new Vector3(num, 0f, num2), true);
				}
				else
				{
					this.Translate(new Vector3(num, num2, 0f), true);
				}
			}
			else if (Input.GetMouseButton(0))
			{
				if (this.mouseRevX)
				{
					num *= -1f;
				}
				if (this.mouseRevY)
				{
					num2 *= -1f;
				}
				flag = true;
				this.Rotate(new Vector3(-num2, num, 0f));
			}
			else if (Input.GetMouseButton(2))
			{
				flag = true;
				if (this.centerDragMove == IllusionCamera.CenterDragMove.XY)
				{
					this.Translate(new Vector3(num, num2, 0f), true);
				}
				else
				{
					this.Translate(new Vector3(num, 0f, num2), false);
				}
			}
			else if (Input.GetMouseButton(1))
			{
				flag = true;
				this.distance += num * this.translateSpeed * ConfigData.cameraMoveSpeed;
				this.Translate(new Vector3(0f, num2, 0f), false);
			}
		}
		flag |= this.KeyInput();
		this.distance = Mathf.Clamp(this.distance, this.minDistance, this.maxDistance);
		this.nowCenterOffset.x = Tween.Spring(this.nowCenterOffset.x, this.setCenterOffset.x, 5f, Time.deltaTime, 0.01f, 0f);
		this.nowCenterOffset.y = Tween.Spring(this.nowCenterOffset.y, this.setCenterOffset.y, 5f, Time.deltaTime, 0.01f, 0f);
		if (this.focusIpoRate < 1f)
		{
			this.focusIpoRate = Tween.Spring(this.focusIpoRate, 1f, 8f, Time.deltaTime, 0.1f, 0f);
			this.nowFocus = Vector3.Lerp(this.prevFocus, this.setFocus, this.focusIpoRate);
		}
		else
		{
			this.nowFocus = this.setFocus;
		}
		base.transform.position = this.CalcPos();
		this.viewCollider.height = this.distance;
		this.viewCollider.center = Vector3.forward * this.distance * 0.5f;
		if (this.target && flag)
		{
			this.target.Move(this.nowFocus, this.showTgt);
		}
		this.HitCheck();
	}

	// Token: 0x0600070F RID: 1807 RVA: 0x00029CF4 File Offset: 0x00027EF4
	private void ButtonStateCheck()
	{
		for (int i = 0; i < 3; i++)
		{
			if (Input.GetMouseButtonDown(i))
			{
				this.buttonState[i] = IllusionCamera.ButtonState.DOWN;
			}
			else if (Input.GetMouseButtonUp(i))
			{
				this.buttonState[i] = IllusionCamera.ButtonState.UP;
			}
			else if (Input.GetMouseButton(i))
			{
				this.buttonState[i] = IllusionCamera.ButtonState.HOLD;
			}
			else
			{
				this.buttonState[i] = IllusionCamera.ButtonState.NO;
			}
		}
	}

	// Token: 0x06000710 RID: 1808 RVA: 0x00029D68 File Offset: 0x00027F68
	public void Set(Vector3 focus, Vector3 rotate, float distance, float parse = 0f)
	{
		this.nowFocus = focus;
		this.setFocus = focus;
		this.focusIpoRate = 1f;
		this.rotate = rotate;
		this.distance = distance;
		if (parse > 0f)
		{
			this.camera.fieldOfView = parse;
		}
		if (this.target)
		{
			this.target.Move(focus, this.showTgt);
		}
		this.areaCenter = new Vector3?(focus);
	}

	// Token: 0x06000711 RID: 1809 RVA: 0x00029DE4 File Offset: 0x00027FE4
	public void SetFocus(Vector3 focus, bool ipo = false)
	{
		this.setFocus = focus;
		if (ipo)
		{
			this.prevFocus = this.nowFocus;
			this.focusIpoRate = 0f;
		}
		else
		{
			this.nowFocus = focus;
			this.focusIpoRate = 1f;
		}
		if (this.target)
		{
			this.target.Move(focus, this.showTgt);
		}
	}

	// Token: 0x06000712 RID: 1810 RVA: 0x00029E50 File Offset: 0x00028050
	public void SetDistance(float distance)
	{
		this.distance = distance;
	}

	// Token: 0x06000713 RID: 1811 RVA: 0x00029E5C File Offset: 0x0002805C
	public void SetParse(float parse, bool changeDistance)
	{
		float num = this.distance * this.camera.fieldOfView;
		this.camera.fieldOfView = parse;
		if (changeDistance)
		{
			this.distance = num / this.camera.fieldOfView;
		}
	}

	// Token: 0x06000714 RID: 1812 RVA: 0x00029EA4 File Offset: 0x000280A4
	private void Translate(Vector3 vec, bool localTranslate)
	{
		Vector3 point = this.translateSpeed * ConfigData.cameraMoveSpeed * vec;
		if (localTranslate)
		{
			Quaternion rotation = Quaternion.Euler(this.rotate);
			this.setFocus += rotation * point;
		}
		else
		{
			Quaternion rotation2 = Quaternion.Euler(0f, this.rotate.y, 0f);
			this.setFocus += rotation2 * point;
		}
		if (this.areaCenter != null)
		{
			Vector3 a = this.setFocus - this.areaCenter.Value;
			if (a.magnitude >= this.areaLimit)
			{
				a.Normalize();
				this.setFocus = this.areaCenter.Value + a * this.areaLimit;
			}
		}
	}

	// Token: 0x06000715 RID: 1813 RVA: 0x00029F88 File Offset: 0x00028188
	private void Rotate(Vector3 angles)
	{
		this.rotate += angles * this.rotateSpeed * ConfigData.cameraTurnSpeed;
		float value = Mathf.DeltaAngle(0f, this.rotate.x);
		if (this.pitchLimit >= 0f)
		{
			this.rotate.x = Mathf.Clamp(value, -this.pitchLimit, this.pitchLimit);
		}
	}

	// Token: 0x06000716 RID: 1814 RVA: 0x0002A000 File Offset: 0x00028200
	private bool KeyInput_Value(ref float val, float move, KeyCode addKey, KeyCode subKey)
	{
		if (Input.GetKey(addKey))
		{
			this.KeyInput_Accel(ref val, move);
			return true;
		}
		if (Input.GetKey(subKey))
		{
			this.KeyInput_Accel(ref val, -move);
			return true;
		}
		this.KeyInput_Brake(ref val, move);
		return false;
	}

	// Token: 0x06000717 RID: 1815 RVA: 0x0002A038 File Offset: 0x00028238
	private bool KeyInputDown_Value(ref float val, float move, KeyCode addKey, KeyCode subKey)
	{
		if (Input.GetKeyDown(addKey))
		{
			val += move;
			return true;
		}
		if (Input.GetKeyDown(subKey))
		{
			val -= move;
			return true;
		}
		return false;
	}

	// Token: 0x06000718 RID: 1816 RVA: 0x0002A064 File Offset: 0x00028264
	private void KeyInput_Accel(ref float val, float move)
	{
		val += move * this.keyAccel * Time.deltaTime;
		if (move > 0f)
		{
			val = Mathf.Min(val, move);
		}
		else
		{
			val = Mathf.Max(val, move);
		}
	}

	// Token: 0x06000719 RID: 1817 RVA: 0x0002A0A0 File Offset: 0x000282A0
	private void KeyInput_Brake(ref float val, float move)
	{
		float a = Mathf.Abs(val) - move * this.keyBrake * Time.deltaTime;
		if (val > 0f)
		{
			val = Mathf.Max(a, 0f);
		}
		else
		{
			val = -Mathf.Max(a, 0f);
		}
	}

	// Token: 0x0600071A RID: 1818 RVA: 0x0002A0F0 File Offset: 0x000282F0
	private bool KeyInput()
	{
		if (EventSystem.current != null && EventSystem.current.currentSelectedGameObject != null)
		{
			return false;
		}
		bool flag = false;
		if (Input.GetKey(KeyCode.KeypadPlus))
		{
			this.keySensitivity += Time.deltaTime * 0.25f;
		}
		else if (Input.GetKey(KeyCode.KeypadMinus))
		{
			this.keySensitivity = Mathf.Max(this.keySensitivity - Time.deltaTime * 0.25f, 0f);
		}
		KeyCode addKey = this.keyRevX ? KeyCode.Keypad4 : KeyCode.Keypad6;
		KeyCode subKey = this.keyRevX ? KeyCode.Keypad6 : KeyCode.Keypad4;
		KeyCode addKey2 = this.keyRevY ? KeyCode.Keypad8 : KeyCode.Keypad2;
		KeyCode subKey2 = this.keyRevY ? KeyCode.Keypad2 : KeyCode.Keypad8;
		flag |= this.KeyInput_Value(ref this.keyRotSpeed.y, this.keySensitivity, addKey, subKey);
		flag |= this.KeyInput_Value(ref this.keyRotSpeed.x, this.keySensitivity, addKey2, subKey2);
		if (Input.GetKey(KeyCode.Keypad5))
		{
			this.rotate.x = 0f;
			this.keyRotSpeed.x = 0f;
			flag = true;
		}
		flag |= this.KeyInput_Value(ref this.keyMovSpeed.x, this.keySensitivity, KeyCode.RightArrow, KeyCode.LeftArrow);
		flag |= this.KeyInput_Value(ref this.keyMovSpeed.z, this.keySensitivity, KeyCode.UpArrow, KeyCode.DownArrow);
		flag |= this.KeyInput_Value(ref this.keyMovSpeed.y, this.keySensitivity, KeyCode.PageUp, KeyCode.PageDown);
		flag |= this.KeyInput_Value(ref this.keyDisSpeed, this.keySensitivity * 0.2f, KeyCode.End, KeyCode.Home);
		if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
		{
			bool flag2 = this.KeyInputDown_Value(ref this.rotate.z, 45f, KeyCode.Period, KeyCode.Backslash);
			flag = (flag || flag2);
			if (flag2)
			{
				this.keyRotSpeed.z = 0f;
			}
		}
		else
		{
			flag |= this.KeyInput_Value(ref this.keyRotSpeed.z, this.keySensitivity * 0.5f, KeyCode.Period, KeyCode.Backslash);
		}
		if (Input.GetKey(KeyCode.Slash))
		{
			this.rotate.z = 0f;
			this.keyRotSpeed.z = 0f;
			flag = true;
		}
		float num = this.keySensitivity * 0.2f;
		if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
		{
			num *= 3f;
		}
		flag |= this.KeyInput_Value(ref this.keyFovSpeed, num, KeyCode.RightBracket, KeyCode.Equals);
		if (Input.GetKey(KeyCode.Semicolon))
		{
			this.camera.fieldOfView = this.defParse;
			this.keyFovSpeed = 0f;
			flag = true;
		}
		if (this.keyRotSpeed.magnitude != 0f)
		{
			this.Rotate(this.keyRotSpeed);
		}
		if (this.keyMovSpeed.magnitude != 0f)
		{
			Vector3 vec = new Vector3(this.keyMovSpeed.x, this.keyMovSpeed.y, 0f);
			Vector3 vec2 = new Vector3(0f, 0f, this.keyMovSpeed.z);
			this.Translate(vec, false);
			this.Translate(vec2, true);
			flag = true;
		}
		if (this.keyFovSpeed != 0f)
		{
			this.camera.fieldOfView += this.keyFovSpeed * 2f;
			this.camera.fieldOfView = Mathf.Clamp(this.camera.fieldOfView, 5f, 90f);
		}
		if (this.keyDisSpeed != 0f)
		{
			this.distance += this.keyDisSpeed;
		}
		if (Input.GetKeyDown(KeyCode.Alpha2))
		{
			ConfigData.showFocusUI = !ConfigData.showFocusUI;
			SystemSE.SE se = (!ConfigData.showFocusUI) ? SystemSE.SE.NO : SystemSE.SE.YES;
			SystemSE.Play(se);
			Config config = UnityEngine.Object.FindObjectOfType<Config>();
			if (config)
			{
				config.UpdateFromShortCut();
			}
		}
		return flag;
	}

	// Token: 0x0600071B RID: 1819 RVA: 0x0002A55C File Offset: 0x0002875C
	public Vector3 GetDirection()
	{
		return base.transform.rotation * Vector3.forward;
	}

	// Token: 0x0600071C RID: 1820 RVA: 0x0002A574 File Offset: 0x00028774
	public Vector3 GetTargetPos()
	{
		return this.target.transform.position;
	}

	// Token: 0x0600071D RID: 1821 RVA: 0x0002A588 File Offset: 0x00028788
	private void HitCheck()
	{
		int num = 0;
		Vector3 position = base.transform.position;
		Vector3 vector = this.rotate;
		while (Physics.CheckSphere(position, this.hitRadius, this.hitLayer))
		{
			this.distance += this.hitRadius * 0.1f;
			position = this.CalcPos();
			num++;
			if (num == 10)
			{
				this.distance += this.hitRadius;
				break;
			}
		}
		base.transform.position = position;
	}

	// Token: 0x0600071E RID: 1822 RVA: 0x0002A61C File Offset: 0x0002881C
	private Vector3 CalcPos()
	{
		Vector3 screen = Vector2.zero;
		screen.x = (float)this.camera.pixelWidth * (this.nowCenterOffset.x * 0.5f + 0.5f);
		screen.y = (float)this.camera.pixelHeight * (this.nowCenterOffset.y * 0.5f + 0.5f);
		Vector3 vector = this.Unproj(screen);
		vector *= -this.distance;
		vector.z = 0f;
		Quaternion rotation = Quaternion.Euler(this.rotate);
		base.transform.rotation = rotation;
		Vector3 b = rotation * vector;
		Vector3 b2 = rotation * (Vector3.back * this.distance);
		return this.nowFocus + b + b2;
	}

	// Token: 0x0600071F RID: 1823 RVA: 0x0002A6F8 File Offset: 0x000288F8
	private Vector3 Unproj(Vector3 screen)
	{
		Matrix4x4 m = Matrix4x4.identity;
		m = Matrix4x4.Inverse(m);
		Matrix4x4 identity = Matrix4x4.identity;
		identity.m00 = (float)(this.camera.pixelWidth / 2);
		identity.m30 = (float)(this.camera.pixelWidth / 2);
		identity.m11 = (float)(-(float)this.camera.pixelHeight / 2);
		identity.m31 = (float)(this.camera.pixelHeight / 2);
		identity.m22 = 1f;
		identity.m33 = 1f;
		Matrix4x4 rhs = Matrix4x4.Inverse(identity);
		Matrix4x4 rhs2 = Matrix4x4.Inverse(this.camera.projectionMatrix);
		Matrix4x4 rhs3 = Matrix4x4.Inverse(m);
		Matrix4x4 identity2 = Matrix4x4.identity;
		identity2.m00 = (identity2.m10 = (identity2.m20 = (identity2.m30 = screen.x)));
		identity2.m01 = (identity2.m11 = (identity2.m21 = (identity2.m31 = screen.y)));
		identity2.m02 = (identity2.m12 = (identity2.m22 = (identity2.m32 = screen.z)));
		identity2.m03 = (identity2.m13 = (identity2.m23 = (identity2.m33 = 1f)));
		Matrix4x4 matrix4x = identity2 * rhs * rhs2 * rhs3;
		return new Vector3(matrix4x.m00, matrix4x.m01, matrix4x.m02);
	}

	// Token: 0x06000720 RID: 1824 RVA: 0x0002A8A4 File Offset: 0x00028AA4
	public void SetDefParse(float defParse)
	{
		this.defParse = defParse;
	}

	// Token: 0x040006F8 RID: 1784
	private Camera camera;

	// Token: 0x040006F9 RID: 1785
	[SerializeField]
	private float mouseSensitivity = 1f;

	// Token: 0x040006FA RID: 1786
	[SerializeField]
	private float keySensitivity = 1f;

	// Token: 0x040006FB RID: 1787
	[SerializeField]
	private float rotateSpeed = 10f;

	// Token: 0x040006FC RID: 1788
	[SerializeField]
	private float translateSpeed = 0.25f;

	// Token: 0x040006FD RID: 1789
	[SerializeField]
	private float keyAccel = 5f;

	// Token: 0x040006FE RID: 1790
	[SerializeField]
	private float keyBrake = 5f;

	// Token: 0x040006FF RID: 1791
	[SerializeField]
	private Vector3 setFocus = new Vector3(0f, 0f, 0f);

	// Token: 0x04000700 RID: 1792
	private Vector3 nowFocus = new Vector3(0f, 0f, 0f);

	// Token: 0x04000701 RID: 1793
	private Vector3 prevFocus = new Vector3(0f, 0f, 0f);

	// Token: 0x04000702 RID: 1794
	private float focusIpoRate = 1f;

	// Token: 0x04000703 RID: 1795
	[SerializeField]
	private Vector3 rotate = new Vector3(0f, 0f, 0f);

	// Token: 0x04000704 RID: 1796
	[SerializeField]
	private float distance = 1.5f;

	// Token: 0x04000705 RID: 1797
	[SerializeField]
	private float defParse = 45f;

	// Token: 0x04000706 RID: 1798
	[SerializeField]
	private float minDistance;

	// Token: 0x04000707 RID: 1799
	[SerializeField]
	private float maxDistance = 10f;

	// Token: 0x04000708 RID: 1800
	[SerializeField]
	private bool mouseRevY;

	// Token: 0x04000709 RID: 1801
	[SerializeField]
	private bool mouseRevX;

	// Token: 0x0400070A RID: 1802
	[SerializeField]
	private bool keyRevY;

	// Token: 0x0400070B RID: 1803
	[SerializeField]
	private bool keyRevX;

	// Token: 0x0400070C RID: 1804
	[SerializeField]
	private CameraTarget target;

	// Token: 0x0400070D RID: 1805
	[SerializeField]
	private bool showTgt = true;

	// Token: 0x0400070E RID: 1806
	[SerializeField]
	private bool dragLock = true;

	// Token: 0x0400070F RID: 1807
	[SerializeField]
	private IllusionCamera.CenterDragMove centerDragMove = IllusionCamera.CenterDragMove.XZ;

	// Token: 0x04000710 RID: 1808
	private Vector2 nowCenterOffset = Vector2.zero;

	// Token: 0x04000711 RID: 1809
	public Vector2 setCenterOffset = Vector2.zero;

	// Token: 0x04000712 RID: 1810
	public float distanceOffset;

	// Token: 0x04000713 RID: 1811
	private Vector3 keyRotSpeed = new Vector3(0f, 0f, 0f);

	// Token: 0x04000714 RID: 1812
	private Vector3 keyMovSpeed = new Vector3(0f, 0f, 0f);

	// Token: 0x04000715 RID: 1813
	private float keyDisSpeed;

	// Token: 0x04000716 RID: 1814
	private float keyFovSpeed;

	// Token: 0x04000717 RID: 1815
	private CapsuleCollider viewCollider;

	// Token: 0x04000718 RID: 1816
	private IllusionCamera.ButtonState[] buttonState = new IllusionCamera.ButtonState[3];

	// Token: 0x04000719 RID: 1817
	private bool dragging;

	// Token: 0x0400071C RID: 1820
	public float areaLimit = 10f;

	// Token: 0x0400071D RID: 1821
	public Vector3? areaCenter;

	// Token: 0x0400071E RID: 1822
	public float hitRadius = 0.1f;

	// Token: 0x0400071F RID: 1823
	public LayerMask hitLayer = 0;

	// Token: 0x04000720 RID: 1824
	public float pitchLimit = 80f;

	// Token: 0x02000139 RID: 313
	private enum MouseButton
	{
		// Token: 0x04000722 RID: 1826
		MB_LEFT,
		// Token: 0x04000723 RID: 1827
		MB_RIGHT,
		// Token: 0x04000724 RID: 1828
		MB_MIDDLE,
		// Token: 0x04000725 RID: 1829
		NUM
	}

	// Token: 0x0200013A RID: 314
	private enum ButtonState
	{
		// Token: 0x04000727 RID: 1831
		NO,
		// Token: 0x04000728 RID: 1832
		DOWN,
		// Token: 0x04000729 RID: 1833
		HOLD,
		// Token: 0x0400072A RID: 1834
		UP
	}

	// Token: 0x0200013B RID: 315
	public enum CenterDragMove
	{
		// Token: 0x0400072C RID: 1836
		XY,
		// Token: 0x0400072D RID: 1837
		XZ
	}
}
